package com.abaaba.project2.service.wx.wxserviceimpl;

import com.abaaba.project2.bean.*;
import com.abaaba.project2.bean.bo.*;
import com.abaaba.project2.bean.data.SelectCouponInfo;
import com.abaaba.project2.bean.data.WxCouponInfo1;
import com.abaaba.project2.bean.data.WxCouponInfo2;
import com.abaaba.project2.bean.data.WxUserCouponInfo;
import com.abaaba.project2.bean.vo.AddCouponVo;
import com.abaaba.project2.bean.vo.wx.*;
import com.abaaba.project2.mapper.CartMapper;
import com.abaaba.project2.mapper.CouponMapper;
import com.abaaba.project2.mapper.Coupon_UserMapper;
import com.abaaba.project2.service.wx.WxCartService;
import com.abaaba.project2.service.wx.WxCouponService;
import com.abaaba.project2.util.DateToStringUtil;
import com.abaaba.project2.util.PageHelperUtil;
import com.abaaba.project2.util.UserIdUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.lang.System;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
public class WxCouponServiceImpl implements WxCouponService {

    @Autowired
    CouponMapper couponMapper;

    @Autowired
    Coupon_UserMapper coupon_userMapper;

    @Autowired
    CartMapper cartMapper;

    @Autowired
    WxCartService wxCartService;

    @Override
    public WxUserCouponListVo wxUserCouponList(WxUserCouponListBo wxUserCouponListBo) {
        //这里要注意：要根据登陆用户的id的不同，显示他们自己的优惠券（要用userId）
        //这里根据状态status值的不同，从coupon_user表中查询出对应的优惠券即可
        //从数据库中查询数据进行显示时，注意这里还要考虑：
        //如果当前时间已经超出了某张优惠券的使用时间，则该优惠券过期，即使status=0，也应该将其改为2
        //获取status值
        Short status = wxUserCouponListBo.getStatus();
        //进行分页查询
        PageHelper.startPage(wxUserCouponListBo.getPage(), wxUserCouponListBo.getSize());

        //创建example对象
        Coupon_UserExample coupon_userExample = new Coupon_UserExample();
        Coupon_UserExample.Criteria criteria = coupon_userExample.createCriteria();
        criteria.andDeletedEqualTo(false).andStatusEqualTo(status).andUserIdEqualTo(UserIdUtil.getUserId());
        List<Coupon_User> coupon_users = coupon_userMapper.selectByExample(coupon_userExample);

        //获得分页信息
        PageInfo<Coupon_User> coupon_userPageInfo = new PageInfo<>(coupon_users);
        long total = coupon_userPageInfo.getTotal();
        WxUserCouponListVo wxUserCouponListVo = new WxUserCouponListVo();
        wxUserCouponListVo.setCount(total);

        ArrayList<WxUserCouponInfo> wxUserCouponInfos = new ArrayList<>();
        for (Coupon_User coupon_user : coupon_users) {
            //这里要注意satus等于0的情况，此时的时间可能已经超过了优惠券的使用时间
            //应该将数据库中该条记录的status修改为2（表示优惠券已经过期）
            //并且该对象不应该被添加到list中
            //获取当前时间
            Date date = new Date(System.currentTimeMillis());
            //Date startTime = coupon_user.getStartTime();
            Date endTime = coupon_user.getEndTime();
            if (coupon_user.getStatus() == 0 && date.after(endTime)) {
                //coupon_userExample.set
                Short newStatus = 2;
                coupon_user.setStatus(newStatus);
                coupon_userMapper.updateByPrimaryKey(coupon_user);
            } else {
                WxUserCouponInfo wxUserCouponInfo = new WxUserCouponInfo();
                //根据couponId从coupon表中查询出coupon记录，获取该coupon的信息
                Integer couponId = coupon_user.getCouponId();
                Coupon coupon = couponMapper.selectByPrimaryKey(couponId);
                wxUserCouponInfo.setId(couponId);
                wxUserCouponInfo.setName(coupon.getName());
                wxUserCouponInfo.setDesc(coupon.getDesc());
                wxUserCouponInfo.setTag(coupon.getTag());
                wxUserCouponInfo.setMin(coupon.getMin().toString());
                wxUserCouponInfo.setDiscount(coupon.getDiscount().toString());
                wxUserCouponInfo.setStartTime(DateToStringUtil.dateToString(coupon_user.getStartTime()));
                wxUserCouponInfo.setEndTime(DateToStringUtil.dateToString(coupon_user.getEndTime()));
                wxUserCouponInfos.add(wxUserCouponInfo);
            }
        }
        wxUserCouponListVo.setData(wxUserCouponInfos);

        return wxUserCouponListVo;
    }

    @Override
    public WxCouponListVo wuCouponList(WxCouponListBo wxCouponListBo) {
        //进行分页查询
        PageHelper.startPage(wxCouponListBo.getPage(), wxCouponListBo.getSize());

        //直接查询即可：deleted = 0；
        //创建example对象
        CouponExample couponExample = new CouponExample();
        CouponExample.Criteria criteria = couponExample.createCriteria();

        //排序信息
        couponExample.setOrderByClause("add_time" + " " + "desc");

        //拼接sql语句
        criteria.andDeletedEqualTo(false);
        List<Coupon> coupons = couponMapper.selectByExample(couponExample);

        //获得分页信息
        PageInfo<Coupon> couponPageInfo = new PageInfo<>(coupons);
        long total = couponPageInfo.getTotal();
        WxCouponListVo wxCouponListVo = new WxCouponListVo();
        wxCouponListVo.setCount(total);

        ArrayList<Object> objects = new ArrayList<>();
        for (Coupon coupon : coupons) {
            if (coupon.getStartTime() == null && coupon.getEndTime() == null) {
                WxCouponInfo2 wxCouponInfo = new WxCouponInfo2();
                wxCouponInfo.setId(coupon.getId());
                wxCouponInfo.setName(coupon.getName());
                wxCouponInfo.setDesc(coupon.getDesc());
                wxCouponInfo.setTag(coupon.getTag());
                wxCouponInfo.setDiscount(coupon.getDiscount());
                wxCouponInfo.setMin(coupon.getMin());
                wxCouponInfo.setDays(coupon.getDays());
                objects.add(wxCouponInfo);
            } else {
                WxCouponInfo1 wxCouponInfo = new WxCouponInfo1();
                wxCouponInfo.setId(coupon.getId());
                wxCouponInfo.setName(coupon.getName());
                wxCouponInfo.setDesc(coupon.getDesc());
                wxCouponInfo.setTag(coupon.getTag());
                wxCouponInfo.setDiscount(coupon.getDiscount());
                wxCouponInfo.setMin(coupon.getMin());
                wxCouponInfo.setDays(coupon.getDays());
                wxCouponInfo.setStartTime(DateToStringUtil.dateToString(coupon.getStartTime()));
                wxCouponInfo.setEndTime(DateToStringUtil.dateToString(coupon.getEndTime()));
                objects.add(wxCouponInfo);
            }
        }
        wxCouponListVo.setData(objects);
        return wxCouponListVo;
    }

    @Override
    public WxReceiveCouponVo wxReceiveCoupon(WxReceiveCouponBo wxReceiveCouponBo) {
        //领取优惠券的逻辑：
        //注意这里的优惠券的领取只包含全场通用的券
        //领取条件：
        // 1.根据每人限领的数量进行判断，该用户是否能领取该优惠券,这里要从coupon_user表中查询couponId
        // 2.三种情况：领取成功，不能再领取了，该优惠券已被领取完了
        //对后台来说：每领取一张优惠券、则将该优惠券的数量减一，这需要根据couponId从coupon表中查询对应记录，
        // 将其total值减1，并且如果某类优惠券的total<=0是不可以领取的

        //得到优惠券id
        Integer couponId = wxReceiveCouponBo.getCouponId();
        //根据couponId向coupon表中查询记录，获取该记录的total值，total值>0并且该用户领取次数没有超过限制，则可以领取
        //要想获得用户领取次数，则需要根据userId和couponId从数据库中查询，那么如何获取userId呢？-->session
        //使用工具类获取当前登录用户的id
        Integer userId = UserIdUtil.getUserId();
        //创建example对象
        CouponExample couponExample = new CouponExample();
        CouponExample.Criteria criteria = couponExample.createCriteria();
        Coupon_UserExample coupon_userExample = new Coupon_UserExample();
        Coupon_UserExample.Criteria criteria1 = coupon_userExample.createCriteria();

        //创建Vo对象
        WxReceiveCouponVo wxReceiveCouponVo = new WxReceiveCouponVo();

        //获取total值、领取限制次数
        //查询出对应记录
        Coupon coupon = couponMapper.selectByPrimaryKey(couponId);
        Integer total = coupon.getTotal();
        Short limit = coupon.getLimit();
        if (total <= 0) {
            wxReceiveCouponVo.setErrno(500);
            wxReceiveCouponVo.setErrmsg("该优惠券已经被领取完了");
            return wxReceiveCouponVo;
        }

        //获取用户的领取次数
        criteria1.andCouponIdEqualTo(couponId);
        criteria1.andUserIdEqualTo(userId);
        List<Coupon_User> coupon_users = coupon_userMapper.selectByExample(coupon_userExample);
        int receiveNum = coupon_users.size();
        if (receiveNum >= limit) {
            wxReceiveCouponVo.setErrno(740);
            wxReceiveCouponVo.setErrmsg("领取次数超过限制");
            return wxReceiveCouponVo;
        }
        //领取成功后，更新coupon表中对应记录的total值（减少1）
        Integer newTotal = total - 1;
        criteria.andIdEqualTo(couponId);
        Coupon coupon1 = new Coupon();
        coupon1.setId(couponId);
        coupon1.setTotal(newTotal);
        couponMapper.updateByPrimaryKeySelective(coupon1);
        wxReceiveCouponVo.setErrno(0);
        wxReceiveCouponVo.setErrmsg("成功");

        //领取成功后向user_coupon表中插入数据,暂时无法获取userId先不插入
        Coupon_User coupon_user = new Coupon_User();
        coupon_user.setCouponId(couponId);
        coupon_user.setUserId(userId);
        Short status = 0;
        coupon_user.setStatus(status);
        //获取系统当前时间,也就是用户领取优惠券的时间
        //如果该优惠券的有效时间基于天数，此时需要根据天数来确定coupon_user表中的startTime和endTime
        //如果该优惠券的有效时间基于startTime、endTime
        Date date = new Date(System.currentTimeMillis());
        Short timeType = coupon.getTimeType();
        if (timeType == 0) {
            coupon_user.setStartTime(date);
            long days = coupon.getDays();
            long time = date.getTime();//得到指定日期的毫秒数
            days = days * 24 * 60 * 60 * 1000;//要加上的天数转换成毫秒数
            time += days;
            Date endTime = new Date(time);
            coupon_user.setEndTime(endTime);
        }
        if (timeType == 1) {
            coupon_user.setStartTime(coupon.getStartTime());
            coupon_user.setEndTime(coupon.getEndTime());
        }
        coupon_user.setAddTime(date);
        coupon_user.setUpdateTime(date);
        //coupon_user.setOrderId();
        coupon_userMapper.insertSelective(coupon_user);
        return wxReceiveCouponVo;
    }

    @Override
    public WxReceiveCouponVo wxExchangeCoupon(WxExchangeCouponBo wxExchangeCouponBo) {
        //兑换优惠券的处理思路（同领取优惠券的思路）
        //根据输入的兑换码进行兑换，用户兑换的次数不能超过限制
        //每次兑换后应该减少对应的兑换券的数量，可以根据兑换码去coupon表中查询对应的记录（理论上来说兑换码是唯一的）
        String code = wxExchangeCouponBo.getCode();

        WxReceiveCouponVo wxReceiveCouponVo = new WxReceiveCouponVo();

        //获取example对象
        CouponExample couponExample = new CouponExample();
        CouponExample.Criteria couponCriteria = couponExample.createCriteria();
        Coupon_UserExample coupon_userExample = new Coupon_UserExample();
        Coupon_UserExample.Criteria coupon_userCriteria = coupon_userExample.createCriteria();

        //根据兑换码从数据库中取出coupon记录，然后将相关信息添加到coupon_user表中
        couponCriteria.andCodeEqualTo(code);
        List<Coupon> coupons = couponMapper.selectByExample(couponExample);

        if (coupons.size() != 0) { //该兑换券存在
            Coupon coupon = coupons.get(0);
            Integer couponId = coupon.getId();
            //得到用户的兑换次数,进行判断
            coupon_userCriteria.andCouponIdEqualTo(couponId);
            List<Coupon_User> coupon_users = coupon_userMapper.selectByExample(coupon_userExample);
            int exchange = coupon_users.size();
            if (exchange >= coupon.getLimit()) {  //兑换失败
                wxReceiveCouponVo.setErrno(740);
                wxReceiveCouponVo.setErrmsg("兑换次数超过限制");
                return wxReceiveCouponVo;
            }

            //执行到这说明可以领取
            //1.更新coupon中的total值
            //2.向coupon_user中添加数据
            Integer total = coupon.getTotal();
            coupon.setTotal(--total);
            couponMapper.updateByPrimaryKeySelective(coupon);

            Coupon_User coupon_user = new Coupon_User();
            coupon_user.setUserId(UserIdUtil.getUserId());
            coupon_user.setCouponId(couponId);
            Short status = 0; //未使用状态
            coupon_user.setStatus(status);
            //获取系统当前时间,也就是用户领取优惠券的时间
            //如果该优惠券的有效时间基于天数，此时需要根据天数来确定coupon_user表中的startTime和endTime
            //如果该优惠券的有效时间基于startTime、endTime
            Date date = new Date(System.currentTimeMillis());
            Short timeType = coupon.getTimeType();
            if (timeType == 0) {
                coupon_user.setStartTime(date);
                long days = coupon.getDays();
                long time = date.getTime();//得到指定日期的毫秒数
                days = days * 24 * 60 * 60 * 1000;//要加上的天数转换成毫秒数
                time += days;
                Date endTime = new Date(time);
                coupon_user.setEndTime(endTime);
            }
            if (timeType == 1) {
                coupon_user.setStartTime(coupon.getStartTime());
                coupon_user.setEndTime(coupon.getEndTime());
            }

            coupon_user.setAddTime(date);
            coupon_user.setUpdateTime(date);
            //coupon_user.setOrderId();
            coupon_userMapper.insertSelective(coupon_user);

            wxReceiveCouponVo.setErrno(0);
            wxReceiveCouponVo.setErrmsg("成功");
            return wxReceiveCouponVo;
        } else {
            wxReceiveCouponVo.setErrno(742);
            wxReceiveCouponVo.setErrmsg("兑换码不正确");
            return wxReceiveCouponVo;
        }
    }

    @Override
    public List selectCoupon(WxSelectCouponBo wxSelectCouponBo) {
        //关于下单时优惠券的显示问题，结合实际
        //优惠券的显示应该满足以下几个条件
        //1.当前时间在优惠券的有效期内
        //怎么做？可以获取userId从coupon_user表中查询出用户所拥有的优惠券以及有效时间
        //当前时间与有效时间进行比较
        //2.选择下单的商品价格要大于等于优惠券的最低消费额度，优惠券才会显示
        //根据用户Id从cart表中查询用户所下单的各件商品，进而查询到商品价格，判断该商品下能否显示优惠券

        WxSelectCouponVo wxSelectCouponVo = new WxSelectCouponVo();

        //获取userId
        Integer userId = UserIdUtil.getUserId();
        //获取当前时间
        Date currentDate = new Date(System.currentTimeMillis());
        //根据userId从coupon_user表中查询出与该userId有关的记录
        Coupon_UserExample coupon_userExample = new Coupon_UserExample();
        Coupon_UserExample.Criteria coupon_usercriteria = coupon_userExample.createCriteria();

        CartExample cartExample = new CartExample();
        CartExample.Criteria cartCriteria = cartExample.createCriteria();

        //选出该用户和其优惠券的所有关系
        coupon_usercriteria.andUserIdEqualTo(userId);
        List<Coupon_User> coupon_users = coupon_userMapper.selectByExample(coupon_userExample);

        //选出cart表中与该用户有关的所有记录
        cartCriteria.andUserIdEqualTo(userId).andDeletedEqualTo(false).andCheckedEqualTo(true);
        List<Cart> carts = cartMapper.selectByExample(cartExample);

        ArrayList<SelectCouponInfo> selectCouponInfos = new ArrayList<>();

        CouponExample couponExample = new CouponExample();
        CouponExample.Criteria couponCriteria = couponExample.createCriteria();

//        for (Cart cart : carts) {//针对每件商品进行判断
//            for (Coupon_User coupon_user : coupon_users) {
//                SelectCouponInfo selectCouponInfo = new SelectCouponInfo();
//                Date startTime = coupon_user.getStartTime();
//                Date endTime = coupon_user.getEndTime();
//                if (currentDate.after(startTime) && currentDate.before(endTime)) {//当前时间在使用时间内
//                    //获取当前优惠券价格进行近一步判断
//                    Integer couponId = coupon_user.getCouponId();
//                    Coupon coupon = couponMapper.selectByPrimaryKey(couponId);
//                    String s1 = coupon.getMin().toString();
//                    String s2 = cart.getPrice().toString();
//                    double min = Double.parseDouble(s1);
//                    double goodsPrice = Double.parseDouble(s2);
//                    if (min <= goodsPrice) { //当前商品可以使用该优惠券,但是要注意：要判断该用户拥有的该优惠券的数量，显示的数量不能超过用户拥有的数量
//                        selectCouponInfo.setId(couponId);
//                        selectCouponInfo.setDesc(coupon.getDesc());
//                        selectCouponInfo.setName(coupon.getName());
//                        selectCouponInfo.setTag(coupon.getTag());
//                        selectCouponInfo.setMin(coupon.getMin().toString());
//                        selectCouponInfo.setDiscount(coupon.getDiscount().toString());
//                        selectCouponInfo.setStartTime(DateToStringUtil.dateToString(startTime));
//                        selectCouponInfo.setEndTime(DateToStringUtil.dateToString(endTime));
//                        selectCouponInfos.add(selectCouponInfo);
//                    }
//                } else {
//                    continue;
//                }
//            }
//        }

        //注意：我们要显示的是优惠券，所以应该对每张优惠券进行判断，每张优惠券只出现一次
        //要求：只显示当前商品可以使用的优惠券
        for (Coupon_User coupon_user : coupon_users) {
            //for (Cart cart : carts) {
                SelectCouponInfo selectCouponInfo = new SelectCouponInfo();
                Date startTime = coupon_user.getStartTime();
                Date endTime = coupon_user.getEndTime();
                if (currentDate.after(startTime) && currentDate.before(endTime)) {//当前时间在使用时间内
                    //获取当前优惠券价格进行近一步判断
                    Integer couponId = coupon_user.getCouponId();
                    Coupon coupon = couponMapper.selectByPrimaryKey(couponId);
                    String s1 = coupon.getMin().toString();
                    //String s2 = cart.getPrice().toString();
                    //Short number = cart.getNumber();//获取购物车中该商品的数量
                    double min = Double.parseDouble(s1);
                    //获得商品总价格
                    CheckInfoVo checkInfoVo = wxCartService.checkoutInfo(0,0,-1,0);
                    double actualPrice = checkInfoVo.getActualPrice();
                    //double goodsPrice = Double.parseDouble(s2)*number;
                    if (min <= actualPrice) { //当前选中的购物车的商品可以使用该优惠券,但是要注意：要判断该用户拥有的该优惠券的数量，显示的数量不能超过用户拥有的数量
                        selectCouponInfo.setId(couponId);
                        selectCouponInfo.setDesc(coupon.getDesc());
                        selectCouponInfo.setName(coupon.getName());
                        selectCouponInfo.setTag(coupon.getTag());
                        selectCouponInfo.setMin(coupon.getMin().toString());
                        selectCouponInfo.setDiscount(coupon.getDiscount().toString());
                        selectCouponInfo.setStartTime(DateToStringUtil.dateToString(startTime));
                        selectCouponInfo.setEndTime(DateToStringUtil.dateToString(endTime));
                        selectCouponInfos.add(selectCouponInfo);
                    }
                } else {
                    continue;
                }
            //}
        }

        return selectCouponInfos;
    }
}
